const bluetoothModule = require('../../utils/bluetooth.js')
const bluetoothManager = bluetoothModule.bluetoothManager
const DiscoveryType = bluetoothModule.DiscoveryType
const BluetoothType = bluetoothModule.BluetoothType
const DiscoveredDevice = bluetoothModule.DiscoveredDevice

const gaiaModule = require('../../utils/gaiaManager.js')
const gaiaManager = gaiaModule.gaiaManager


Page({
  data: {
    isScanning: false,
    devices: [],
    statusText: '准备就绪',
    hasBluetoothPermission: false,
    // 与安卓版本一致的设备分类
    deviceCategories: {
      connected: [],
      paired: [],
      discovered: []
    },
    // 显示的消息
    message: null,
    // 是否正在刷新
    isRefreshing: false,
    // 扫描超时时间（秒）
    scanTimeout: 30,
    // 扫描开始时间
    scanStartTime: null,
    // 筛选选项
    filterOptions: {
      showOnlyGaia: true,   // 是否只显示GAIA设备（默认启用）
      showConnected: true,  // 是否显示已连接设备
      showPaired: true,     // 是否显示已配对设备
      showDiscovered: false // 是否显示已发现设备（默认禁用）
    },
  },

  onLoad() {
    this.checkPermission()
    this.initBluetooth()
    // 页面加载完成后自动开始扫描
    setTimeout(() => {
      if (this.data.hasBluetoothPermission) {
        this.startScan()
      }
    }, 1000) // 延迟1秒开始扫描，确保蓝牙初始化完成
  },

  onShow() {
    this.checkPermission()
    // 页面显示时自动开始扫描
    if (this.data.hasBluetoothPermission && !this.data.isScanning) {
      this.startScan()
    }
  },

  onUnload() {
    if (this.data.isScanning) {
      this.stopScan()
    }
    // 清理定时器
    this.clearAllTimers()
  },

  // 清理所有定时器
  clearAllTimers() {
    if (this.scanProgressTimer) {
      clearInterval(this.scanProgressTimer)
      this.scanProgressTimer = null
    }
    if (this.scanTimeoutTimer) {
      clearTimeout(this.scanTimeoutTimer)
      this.scanTimeoutTimer = null
    }
    if (this.messageTimer) {
      clearTimeout(this.messageTimer)
      this.messageTimer = null
    }
  },

  // 检查权限
  async checkPermission() {
    try {
      const res = await wx.getSetting()
      const hasPermission = res.authSetting['scope.bluetooth'] || false
      this.setData({
        hasBluetoothPermission: hasPermission
      })
      return hasPermission
    } catch (error) {
      return false
    }
  },

  // 请求权限
  async requestPermission() {
    try {
      const res = await wx.authorize({
        scope: 'scope.bluetooth'
      })
      this.setData({
        hasBluetoothPermission: true
      })
      this.initBluetooth()
      // 权限获取后立即开始扫描
      setTimeout(() => {
        this.startScan()
      }, 500)
    } catch (error) {
      console.error('请求权限失败:', error)
      wx.showToast({
        title: '需要蓝牙权限',
        icon: 'none'
      })
    }
  },

  // 初始化蓝牙
  async initBluetooth() {
    try {
      const success = await bluetoothManager.init()
      if (success) {
        this.setData({
          statusText: '蓝牙已初始化'
        })
      } else {
        this.setData({
          statusText: '蓝牙初始化失败'
        })
      }
      return success
    } catch (error) {
      console.error('蓝牙初始化失败:', error)
      this.setData({
        statusText: '蓝牙初始化失败'
      })
      return false
    }
  },

  // 切换扫描状态
  async toggleScan() {
    if (this.data.isScanning) {
      await this.stopScan()
    } else {
      await this.startScan()
    }
  },

  // 手动刷新设备列表
  async refreshDevices() {
    if (this.data.isScanning) {
      return
    }
    
    // 清空当前设备列表
    this.setData({
      devices: [],
      deviceCategories: {
        connected: [],
        paired: [],
        discovered: []
      },
      message: null
    })

    // 重新开始扫描
    await this.startScan()
  },

  // 开始扫描（与安卓版本一致）
  async startScan() {
    
    if (!this.data.hasBluetoothPermission) {
      wx.showToast({
        title: '请先授权蓝牙权限',
        icon: 'none'
      })
      await this.requestPermission()
      return
    }

    // 检查蓝牙是否可用
    try {
      const adapterState = await wx.getBluetoothAdapterState()
      
      if (!adapterState.available) {
        this.setData({
          statusText: '蓝牙不可用'
        })
        wx.showToast({
          title: '请开启蓝牙',
          icon: 'none'
        })
        return
      }
      
      if (!adapterState.discovering) {
      }
    } catch (error) {
    }

    try {
      this.setData({
        isScanning: true,
        isRefreshing: true,
        statusText: '正在扫描...',
        devices: [],
        deviceCategories: {
          connected: [],
          paired: [],
          discovered: []
        },
        message: null,
        scanStartTime: Date.now()
      })

      // 设置设备发现回调
      bluetoothManager.setOnDeviceFound((device) => {
        this.addDevice(device)
      })

      // 开始扫描
      await bluetoothManager.startScan(DiscoveryType.DISCOVERED)
      
      this.setData({
        statusText: '扫描中...'
      })

      // 设置扫描超时
      this.scanTimeoutTimer = setTimeout(() => {
        if (this.data.isScanning) {
          this.stopScan()
        }
      }, this.data.scanTimeout * 1000)

      // 添加扫描进度提示
      this.startScanProgress()
      
    } catch (error) {
      console.error('开始扫描失败:', error)
      this.setData({
        isScanning: false,
        isRefreshing: false,
        statusText: '扫描失败'
      })
      wx.showToast({
        title: '扫描失败: ' + (error.errMsg || error.message || '未知错误'),
        icon: 'none',
        duration: 3000
      })
    }
  },

  // 停止扫描
  async stopScan() {
    try {
      await bluetoothManager.stopScan()
      
      // 清理超时定时器
      if (this.scanTimeoutTimer) {
        clearTimeout(this.scanTimeoutTimer)
        this.scanTimeoutTimer = null
      }
      
      this.setData({
        isScanning: false,
        isRefreshing: false,
        statusText: '扫描已停止'
      })
      
      // 停止扫描进度提示
      this.stopScanProgress()
      
      // 显示扫描结果统计
      this.showScanResults()
      
    } catch (error) {
      console.error('停止扫描失败:', error)
      // 即使停止失败，也要更新状态
      this.setData({
        isScanning: false,
        isRefreshing: false,
        statusText: '扫描已停止'
      })
    }
  },

  // 开始扫描进度提示
  startScanProgress() {
    this.scanProgressTimer = setInterval(() => {
      if (this.data.isScanning) {
        const { filterOptions, deviceCategories } = this.data
        const totalDevices = deviceCategories.connected.length + 
                           deviceCategories.paired.length + 
                           deviceCategories.discovered.length
        
        // 计算GAIA设备数量
        const totalGaiaDevices = [deviceCategories.connected, deviceCategories.paired, deviceCategories.discovered]
          .flat()
          .filter(device => device.isGaiaDevice).length
        
        const elapsed = Math.floor((Date.now() - this.data.scanStartTime) / 1000)
        const remaining = Math.max(0, this.data.scanTimeout - elapsed)
        
        let statusText = `扫描中... 已发现 ${totalDevices} 个设备`
        if (filterOptions.showOnlyGaia) {
          statusText += ` (${totalGaiaDevices} 个GAIA设备)`
        }
        statusText += ` (${remaining}s)`
        
        this.setData({
          statusText: statusText
        })
      }
    }, 2000) // 每2秒更新一次
  },

  // 停止扫描进度提示
  stopScanProgress() {
    if (this.scanProgressTimer) {
      clearInterval(this.scanProgressTimer)
      this.scanProgressTimer = null
    }
  },

  // 显示扫描结果统计
  showScanResults() {
    const { filterOptions, deviceCategories } = this.data
    const totalDevices = deviceCategories.connected.length + 
                       deviceCategories.paired.length + 
                       deviceCategories.discovered.length
    
    // 计算GAIA设备数量
    const totalGaiaDevices = [deviceCategories.connected, deviceCategories.paired, deviceCategories.discovered]
      .flat()
      .filter(device => device.isGaiaDevice).length
    
    
    if (totalDevices === 0) {
      this.setData({
        message: {
          type: 'info',
          text: '未发现任何设备，请确保：\n1. 设备已开启蓝牙\n2. 设备在有效范围内\n3. 设备处于可发现状态'
        }
      })
    } else {
      let messageText = `扫描完成，共发现 ${totalDevices} 个设备`
      
      if (filterOptions.showOnlyGaia) {
        messageText += `\n其中 ${totalGaiaDevices} 个GAIA设备`
        if (totalGaiaDevices === 0) {
          messageText += '\n未发现GAIA设备，请检查设备是否支持GAIA协议'
        }
      } else if (totalGaiaDevices > 0) {
        messageText += `\n其中 ${totalGaiaDevices} 个GAIA设备`
      }
      
      this.setData({
        message: {
          type: 'success',
          text: messageText
        }
      })
      
      // 3秒后清除消息
      this.messageTimer = setTimeout(() => {
        this.setData({
          message: null
        })
      }, 3000)
    }
  },

  // 添加设备到列表（与安卓版本一致）
  addDevice(device) {
    const deviceCategories = this.data.deviceCategories
    
    // 根据发现类型分类设备
    switch (device.discoveryType) {
      case DiscoveryType.CONNECTED:
        this.addDeviceToCategory(deviceCategories.connected, device)
        break
      case DiscoveryType.PAIRED:
        this.addDeviceToCategory(deviceCategories.paired, device)
        break
      case DiscoveryType.DISCOVERED:
      default:
        this.addDeviceToCategory(deviceCategories.discovered, device)
        break
    }
    
    // 更新设备列表
    this.updateDeviceList()
  },

  // 添加设备到指定分类
  addDeviceToCategory(category, device) {
    const existingIndex = category.findIndex(d => 
      d.bluetoothAddress === device.bluetoothAddress && 
      d.bluetoothType === device.bluetoothType
    )
    
    if (existingIndex >= 0) {
      // 更新现有设备信息（保留更好的信号强度）
      const existingDevice = category[existingIndex]
      if (device.RSSI && (!existingDevice.RSSI || device.RSSI > existingDevice.RSSI)) {
        category[existingIndex] = device
      }
    } else {
      // 添加新设备
      category.push(device)
    }
    
    // 按信号强度排序（信号强的排在前面）
    category.sort((a, b) => {
      const rssiA = a.RSSI || -100
      const rssiB = b.RSSI || -100
      return rssiB - rssiA
    })
  },

  // 更新设备列表显示
  updateDeviceList() {
    const { deviceCategories, filterOptions } = this.data
    const allDevices = []
    
    // 应用筛选逻辑
    const filterDevice = (device) => {
      // 如果启用了只显示GAIA设备，则过滤非GAIA设备
      if (filterOptions.showOnlyGaia && !device.isGaiaDevice) {
        return false
      }
      return true
    }
    
    // 按安卓版本的顺序：已连接 -> 已配对 -> 已发现
    if (deviceCategories.connected.length > 0 && filterOptions.showConnected) {
      const filteredConnected = deviceCategories.connected.filter(filterDevice)
      if (filteredConnected.length > 0) {
        allDevices.push({
          type: 'title',
          title: '已连接设备',
          count: filteredConnected.length
        })
        allDevices.push(...filteredConnected)
      }
    }
    
    if (deviceCategories.paired.length > 0 && filterOptions.showPaired) {
      const filteredPaired = deviceCategories.paired.filter(filterDevice)
      if (filteredPaired.length > 0) {
        allDevices.push({
          type: 'title',
          title: '已配对设备',
          count: filteredPaired.length
        })
        allDevices.push(...filteredPaired)
      }
    }
    
    // 特殊处理：即使showDiscovered为false，也要显示GAIA设备
    if (deviceCategories.discovered.length > 0) {
      let discoveredDevices = deviceCategories.discovered
      
      // 如果启用了GAIA筛选，则只显示GAIA设备
      if (filterOptions.showOnlyGaia) {
        discoveredDevices = discoveredDevices.filter(device => device.isGaiaDevice)
      }
      
      // 如果启用了显示已发现设备，或者有GAIA设备需要显示，则添加到列表
      if (filterOptions.showDiscovered || discoveredDevices.length > 0) {
        const filteredDiscovered = discoveredDevices.filter(filterDevice)
        if (filteredDiscovered.length > 0) {
          // 根据筛选状态决定标题
          let title = '已发现设备'
          if (filterOptions.showOnlyGaia && !filterOptions.showDiscovered) {
            title = '发现的GAIA设备'
          }
          
          allDevices.push({
            type: 'title',
            title: title,
            count: filteredDiscovered.length
          })
          allDevices.push(...filteredDiscovered)
        }
      }
    }
    
    this.setData({
      devices: allDevices
    })
    
  },

  // 连接设备（与安卓版本一致）
  async connectDevice(e) {
    const device = e.currentTarget.dataset.device
    
    
    wx.showLoading({
      title: '连接中...'
    })

    try {
      // 先通过蓝牙管理器连接设备
      const connectResult = await bluetoothManager.connectDevice(device.bluetoothAddress, device.name)
      
      // 等待蓝牙连接完全建立
      await new Promise(resolve => setTimeout(resolve, 1000))
      
      // 设置GAIA管理器的设备ID和连接状态
      gaiaManager.setDeviceId(device.bluetoothAddress)
      gaiaManager.setConnected(true)
      
      // 尝试通过 GAIA Manager 连接
      const gaiaResult = await gaiaManager.connect()
      
      // 保存连接的设备信息 - 确保包含所有必要信息
      const deviceInfoToSave = {
        name: device.name,
        bluetoothAddress: device.bluetoothAddress,
        bluetoothType: device.bluetoothType,
        discoveryType: device.discoveryType,
        RSSI: device.RSSI,
        isGaiaDevice: gaiaResult.success, // 根据GAIA连接结果设置
        deviceType: device.deviceType,
        // 添加一些默认的设备信息，以便在信息页面显示
        variantName: device.name,
        batteryLevels: {
          device: null,
          left: null,
          right: null,
          case: null
        },
        serialNumber: null,
        serialNumberLeft: null,
        serialNumberRight: null,
        applicationVersion: null,
        applicationBuildId: null,
        gaiaVersion: null,
        isCharging: false
      }
      
      
      // 保存设备信息到存储
      wx.setStorageSync('lastConnectedDevice', device.bluetoothAddress)
      wx.setStorageSync('connectedDeviceInfo', deviceInfoToSave)
      
      wx.hideLoading()
      
      if (gaiaResult.success) {
        // 根据连接模式显示不同的提示
        const modeText = gaiaResult.mode === 'polling' ? '（轮询模式）' : ''
        
        wx.showToast({
          title: `GAIA 设备连接成功${modeText}`,
          icon: 'success',
          duration: 2000
        })

        // 延迟跳转，让用户看到成功提示
        setTimeout(() => {
          // 跳转到设备信息页面（与安卓版本一致）
          wx.switchTab({
            url: '/pages/information/information'
          })
        }, 2000)
      } else {
        // GAIA连接失败，显示具体错误信息
        const errorMessage = gaiaResult.error || '未知错误'
        
        // 根据错误类型显示不同的提示
        let toastMessage = '设备连接成功，但GAIA连接失败'
        if (errorMessage.includes('notifyBLECharacteristicValueChange')) {
          toastMessage = '设备连接成功，但通知功能初始化失败'
        } else if (errorMessage.includes('连接验证失败')) {
          toastMessage = '设备连接成功，但通信验证失败'
        } else if (errorMessage.includes('特征值不支持通知功能')) {
          toastMessage = '设备连接成功，但设备不支持通知功能'
        }
        
        wx.showToast({
          title: toastMessage,
          icon: 'none',
          duration: 3000
        })

        // 延迟跳转，让用户看到提示
        setTimeout(() => {          
          // 由于information是tabBar页面，使用switchTab
          wx.switchTab({
            url: '/pages/information/information'
          })
        }, 3000)
      }
    } catch (error) {
      wx.hideLoading()
      console.error('连接失败:', error)
      
      // 根据错误类型显示不同的提示
      if (error.errMsg && error.errMsg.includes('already connect')) {
        wx.showToast({
          title: '设备已连接',
          icon: 'none',
          duration: 2000
        })
      } else {
        wx.showToast({
          title: '连接失败: ' + (error.errMsg || error.message || '未知错误'),
          icon: 'none',
          duration: 3000
        })
      }
    }
  },

  // 刷新设备列表
  refreshList() {
    if (this.data.hasBluetoothPermission) {
      this.startScan()
    }
  },

  // 测试跳转功能
  testNavigation() {
    
    // 尝试不同的跳转方式
    wx.switchTab({
      url: '/pages/information/information',
      success: () => {
        wx.showToast({
          title: '跳转成功',
          icon: 'success'
        })
      },
      fail: (error) => {
        console.error('测试跳转失败:', error)
        wx.showToast({
          title: '跳转失败: ' + error.errMsg,
          icon: 'none',
          duration: 3000
        })
      }
    })
  },

  // 测试设备发现功能
  testDeviceDiscovery() {
    
    // 模拟发现一些测试设备
    const testDevices = [
      {
        name: 'Test GAIA Device',
        bluetoothAddress: 'AA:BB:CC:DD:EE:FF',
        discoveryType: 'DISCOVERED',
        bluetoothType: 'LOW_ENERGY',
        RSSI: -65,
        isGaiaDevice: true,
        deviceType: 'headphone'
      },
      {
        name: 'Test Speaker',
        bluetoothAddress: '11:22:33:44:55:66',
        discoveryType: 'DISCOVERED',
        bluetoothType: 'LOW_ENERGY',
        RSSI: -70,
        isGaiaDevice: false,
        deviceType: 'speaker'
      }
    ]
    
    // 添加测试设备到列表
    testDevices.forEach(device => {
      this.addDevice(device)
    })
    
    wx.showToast({
      title: '已添加测试设备',
      icon: 'success'
    })
  },

  // 清除所有设备
  clearAllDevices() {
    
    this.setData({
      devices: [],
      deviceCategories: {
        connected: [],
        paired: [],
        discovered: []
      },
      message: {
        type: 'info',
        text: '已清除所有设备'
      }
    })
    
    // 3秒后清除消息
    this.messageTimer = setTimeout(() => {
      this.setData({
        message: null
      })
    }, 3000)
    
    wx.showToast({
      title: '已清除所有设备',
      icon: 'success'
    })
  },

  // 获取已发现的设备列表
  async getDiscoveredDevices() {
    try {
      const devices = await bluetoothManager.getDiscoveredDevices()
      
      if (devices.length > 0) {
        // 处理已发现的设备
        devices.forEach(device => {
          this.addDevice({
            name: device.name || '未知设备',
            bluetoothAddress: device.deviceId,
            discoveryType: 'DISCOVERED',
            bluetoothType: 'LOW_ENERGY',
            RSSI: device.RSSI,
            isGaiaDevice: false,
            deviceType: 'unknown'
          })
        })
        
        wx.showToast({
          title: `找到 ${devices.length} 个设备`,
          icon: 'success'
        })
      } else {
        wx.showToast({
          title: '未发现任何设备',
          icon: 'none'
        })
      }
    } catch (error) {
      console.error('获取已发现设备失败:', error)
      wx.showToast({
        title: '获取设备列表失败',
        icon: 'none'
      })
    }
  },

  // 获取已连接的设备列表
  async getConnectedDevices() {
    try {
      const devices = await bluetoothManager.getConnectedDevices()
      
      if (devices.length > 0) {
        // 处理已连接的设备
        devices.forEach(device => {
          this.addDevice({
            name: device.name || '未知设备',
            bluetoothAddress: device.deviceId,
            discoveryType: 'CONNECTED',
            bluetoothType: 'LOW_ENERGY',
            RSSI: device.RSSI,
            isGaiaDevice: false,
            deviceType: 'unknown'
          })
        })
        
        wx.showToast({
          title: `找到 ${devices.length} 个已连接设备`,
          icon: 'success'
        })
      } else {
        wx.showToast({
          title: '未发现已连接设备',
          icon: 'none'
        })
      }
    } catch (error) {
      console.error('获取已连接设备失败:', error)
      wx.showToast({
        title: '获取已连接设备失败',
        icon: 'none'
      })
    }
  },

  // 检查蓝牙状态
  async checkBluetoothStatus() {
    try {
      const adapterState = await wx.getBluetoothAdapterState()
      
      let statusText = '蓝牙状态检查: '
      if (adapterState.available) {
        statusText += '可用'
      } else {
        statusText += '不可用'
      }
      
      if (adapterState.connected) {
        statusText += ', 已连接'
      } else {
        statusText += ', 未连接'
      }
      
      if (adapterState.discovering) {
        statusText += ', 正在发现'
      } else {
        statusText += ', 未发现'
      }
      
      this.setData({
        statusText: statusText
      })
      
      wx.showToast({
        title: statusText,
        icon: 'none',
        duration: 3000
      })
    } catch (error) {
      console.error('检查蓝牙状态失败:', error)
      wx.showToast({
        title: '检查蓝牙状态失败',
        icon: 'none'
      })
    }
  },

  // 切换GAIA设备筛选
  toggleGaiaFilter() {
    const { filterOptions } = this.data
    filterOptions.showOnlyGaia = !filterOptions.showOnlyGaia
    
    this.setData({
      filterOptions: filterOptions
    })
    
    
    // 更新设备列表显示
    this.updateDeviceList()
    
    // 显示筛选状态
    wx.showToast({
      title: filterOptions.showOnlyGaia ? '只显示GAIA设备' : '显示所有设备',
      icon: 'none',
      duration: 1500
    })
  },

  // 切换设备类型显示
  toggleDeviceTypeFilter(e) {
    // 从事件对象中获取data-type属性
    const type = e.currentTarget.dataset.type
    if (!type) {
      console.error('未找到筛选类型参数')
      return
    }
    
    const { filterOptions } = this.data
    filterOptions[type] = !filterOptions[type]
    
    this.setData({
      filterOptions: filterOptions
    })
    
    
    // 更新设备列表显示
    this.updateDeviceList()
    
    // 显示筛选状态
    const typeNames = {
      showConnected: '已连接设备',
      showPaired: '已配对设备',
      showDiscovered: '已发现设备'
    }
    
    wx.showToast({
      title: `${typeNames[type]}${filterOptions[type] ? '已显示' : '已隐藏'}`,
      icon: 'none',
      duration: 1500
    })
  },

  // 重置所有筛选
  resetFilters() {
    this.setData({
      filterOptions: {
        showOnlyGaia: true,    // 保持GAIA设备筛选启用
        showConnected: true,   // 显示已连接设备
        showPaired: true,      // 显示已配对设备
        showDiscovered: false  // 不显示已发现设备
      }
    })
        
    // 更新设备列表显示
    this.updateDeviceList()
    
    wx.showToast({
      title: '筛选已重置',
      icon: 'success',
      duration: 1500
    })
  },



})
